
#ifdef a
//调用基类赋值运算符重载的时候注意不要造成无限递归（注意作用域）

//基类无，子类无，可执行，浅拷贝。(调用默认子类赋值运算符重载，进去后首先调用其基类默认的赋值运算符重载函数，然后返回执行子类重载)

//基类无，子类有（未手动调用基类重载），可执行但不符合预期，浅拷贝。（只完成子类个性的赋值，而不会完成基类继承成员的赋值）

//基类无，子类有（手动调用基类重载）：调用子类显性运算符重载函数，然后首先进入基类默认赋值运算符重载函数，运行良好

//基类有，子类无 ，可执行，浅拷贝。(调用子类默认的赋值函数，先进入基类显性赋值重载，然后返回继续执行子类默认重载)

//基类有，子类有（但未调用基类赋值运算符重载函数）：(调用子类的显性赋值运算符重载函数，只完成了子类个性的赋值，而不会完成基类继承成员的赋值)

//基类有，子类有（调用基类赋值运算符重载）：(调用子类显性运算符重载函数，然后首先进入基类赋值运算符重载函数，运行良好)
#include<iostream>
using namespace std;
class Base {
public:
	Base(int b = 10)
		:_b(b)
	{}
 /*
	Base& operator=(const Base& b) {
		if (this != &b) {
			_b = b._b;
		}
		return *this;
	}
*/
	int _b;
};

class Child : public Base
{
public:
	Child(int b, int c)
		:Base(b)
		,_c(c)
	{}

	/*
	Child& operator=(const Child& c){
		if (this != &c) {
			_c = c._c;
		}
		return *this;
	}
	*/

	
	Child& operator=(const Child& c) {
		if (this != &c) {
			__super::operator=(c);
//			Base::operator=(c);
			_c = c._c;
		}
		return *this;
	}
	

	int _c;
};
int main() {

	Child c1(1, 2);
	Child c2(10, 20);
	c1 = c2;

	return 0;
}
#endif 
